/**
 * AI功能模块 - 支持与AI模型的对话
 */

// 从配置中加载默认模型
function getDefaultModel() {
    return CONFIG && CONFIG.model ? CONFIG.model : 'qwen';
}

// 初始化AI聊天
function setupAIPrompt() {
    // 不显示聊天输入区域，保持隐藏状态
    
    // 设置默认模型
    const modelSelect = document.getElementById('model-select');
    if (modelSelect) {
        const defaultModel = getDefaultModel();
        if (defaultModel) {
            const option = modelSelect.querySelector(`option[value="${defaultModel}"]`);
            if (option) {
                modelSelect.value = defaultModel;
            }
        }
    }
    
    // 添加空格触发AI提示的功能
    const editor = document.getElementById('editor');
    if (!editor) return;
    
    editor.addEventListener('keydown', (e) => {
        const selection = window.getSelection();
        if (selection.rangeCount > 0) {
            const range = selection.getRangeAt(0);
            const lineStart = getLineStart(range);
            // 检查是否已存在 AI 对话框
            const existingAIInput = editor.querySelector('.ai-input-container');

            if (e.key === ' ' && lineStart === '' && !existingAIInput) {
                e.preventDefault();
                openAIInput(range);
            }
        }
    });
    
    editor.addEventListener('click', closeAIInputIfOutside);
    
    // 添加 ESC 键监听器来关闭 AI 输入框
    document.addEventListener('keydown', function(event) {
        if (event.key === 'Escape') {
            const aiInput = document.querySelector('.ai-input-container.active');
            if (aiInput) {
                if (aiInput.parentNode) {
                    aiInput.parentNode.removeChild(aiInput);
                }

                // 将光标移动到编辑器最后
                const editor = document.getElementById('editor');
                const selection = window.getSelection();
                const range = document.createRange();
                range.selectNodeContents(editor);
                range.collapse(false);
                selection.removeAllRanges();
                selection.addRange(range);
                
                // 确保光标可见
                editor.scrollTop = editor.scrollHeight;
            }
        }
    });
}

// 获取当前行开头内容
function getLineStart(range) {
    const node = range.startContainer;
    if (node.nodeType === Node.TEXT_NODE) {
        const text = node.textContent;
        const offset = range.startOffset;
        const lineStart = text.slice(0, offset).trim();
        return lineStart;
    }
    return '';
}

// 打开 AI 输入框
function openAIInput(range) {
    const aiInput = document.createElement('div');
    aiInput.className = 'ai-input-container active';
    aiInput.innerHTML = `
        <div class="ai-input-wrapper">
            <textarea class="ai-input" placeholder="有什么可以帮你？" rows="1"></textarea>
            <div class="input-controls">
                <select class="model-select">
                    <option value="qwen">通义千问</option>
                    <option value="qwq-32b">QWQ-32B(思考+回答)</option>
                    <option value="deepseek">Deepseek</option>
                    <option value="r1-qwen-32">Qwen-32B</option>
                    <option value="r1-llama-70">Llama-70B</option>
                </select>
                <button class="ai-send" title="发送消息 (Enter)">
                    <span class="button-text">发送</span>
                </button>
            </div>
        </div>
        <div class="ai-response"></div>
    `;

    // 在光标位置插入 AI 输入框
    if (range.startContainer.nodeType === Node.TEXT_NODE) {
        const textNode = range.startContainer;
        const parent = textNode.parentNode;
        parent.insertBefore(aiInput, textNode);
    } else if (range.startContainer.nodeType === Node.ELEMENT_NODE) {
        const parent = range.startContainer;
        parent.insertBefore(aiInput, range.startContainer.childNodes[range.startOffset] || null);
    }

    const input = aiInput.querySelector('.ai-input');
    const sendButton = aiInput.querySelector('.ai-send');
    const response = aiInput.querySelector('.ai-response');
    const aiModelSelect = aiInput.querySelector('.model-select');
    
    // 设置默认模型
    const defaultModel = getDefaultModel();
    if (defaultModel) {
        const option = aiModelSelect.querySelector(`option[value="${defaultModel}"]`);
        if (option) {
            aiModelSelect.value = defaultModel;
        }
    }
    
    // 自动聚焦到输入框
    setTimeout(() => {
        input.focus();
        
        // 设置输入框初始高度
        input.style.height = '36px';
    }, 10);
    
    // 监听输入，自动调整高度
    input.addEventListener('input', () => {
        // 重置高度
        input.style.height = 'auto';
        // 设置新高度
        input.style.height = (input.scrollHeight) + 'px';
    });
    
    // 修改输入框事件处理
    input.addEventListener('input', () => {
        sendButton.classList.toggle('active', input.value.trim().length > 0);

        // 自动调整高度
        input.style.height = 'auto';
        input.style.height = Math.min(input.scrollHeight, 72) + 'px';

        // 如果内容超过3行，滚动到底部
        if (input.scrollHeight > 72) {
            input.scrollTop = input.scrollHeight;
        }
    });
    
    // 添加键盘事件处理
    input.addEventListener('keydown', (e) => {
        // 确保不会冒泡到编辑器
        e.stopPropagation();
        
        if (e.key === 'Enter') {
            if (e.shiftKey) {
                // Shift + Enter 换行，不做处理让默认行为发生
                return true;
            } else {
                // Enter 发送内容
                e.preventDefault(); // 阻止默认行为（换行）
                
                const trimmedValue = input.value.trim();
                if (trimmedValue) {
                    console.log('Enter键: 发送消息 -', trimmedValue);
                    // 获取当前选中的模型值
                    const modelValue = aiModelSelect.value;
                    // 调用处理函数
                    handleSendMessage(trimmedValue, modelValue, aiInput, response);
                    
                    // 清空输入框并重置高度
                    input.value = '';
                    input.style.height = '36px';
                }
                return false; // 确保不会继续处理
            }
        }
    });
    
    // 修改发送按钮事件处理
    sendButton.addEventListener('click', function(e) {
        e.preventDefault();
        e.stopPropagation();
        
        console.log('发送按钮被点击');
        const trimmedValue = input.value.trim();
        
        if (trimmedValue) {
            console.log('发送按钮: 发送消息 -', trimmedValue);
            const modelValue = aiModelSelect.value;
            handleSendMessage(trimmedValue, modelValue, aiInput, response);
            
            // 清空输入框并重置高度
            input.value = '';
            input.style.height = '36px';
        }
        
        return false;
    });

    // 阻止事件冒泡
    const modelSelect = aiInput.querySelector('.model-select');
    modelSelect.addEventListener('mousedown', (e) => {
        e.stopPropagation(); // 阻止事件冒泡
    });
    
    modelSelect.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡
    });
    
    modelSelect.addEventListener('change', (e) => {
        e.stopPropagation(); // 阻止事件冒泡
    });

    input.focus();
}

// 接受AI回复
function acceptAIResponse(question, answer, aiInput) {
    const editor = document.getElementById('editor');
    
    // 清理回答中的多余空行
    const cleanedAnswer = answer
        .replace(/\n{3,}/g, '\n\n') // 将3个以上换行替换为2个
        .trim();

    // 使用段落结构替代直接插入
    const questionText = `<div class="ai-question" contenteditable="true"><p>问题：${question}</p></div>`;
    
    // 处理回答内容，解析 Markdown 格式
    const formattedAnswer = formatMarkdown(cleanedAnswer);
    const answerText = `<div class="ai-answer" contenteditable="true">${formattedAnswer}</div>`;
    
    // 插入内容
    const content = `${questionText}${answerText}`;
    aiInput.insertAdjacentHTML('beforebegin', content);

    // 移除AI输入框
    if (aiInput.parentNode) {
        aiInput.parentNode.removeChild(aiInput);
    }

    // 恢复并优化光标定位逻辑
    const questionDiv = editor.querySelector('.ai-question:last-of-type');
    if (questionDiv) {
        const selection = window.getSelection();
        const range = document.createRange();
        range.selectNodeContents(questionDiv);
        range.collapse(false); // 将光标定位到问题div的末尾
        selection.removeAllRanges();
        selection.addRange(range);
        questionDiv.focus();
    }
    
    // 保存编辑器内容
    if (typeof savePageContent === 'function') {
        savePageContent();
    }
}

// 拒绝AI回复
function rejectAIResponse(aiInput) {
    const editor = document.getElementById('editor');
    if (!editor) return;

    if (aiInput && aiInput.parentNode) {
        aiInput.parentNode.removeChild(aiInput);

        // 安全地将光标移动到编辑器内
        try {
            // 确保编辑器可见且在文档中
            if (editor && document.body.contains(editor)) {
                // 创建一个新的范围
                const selection = window.getSelection();
                if (!selection) return;
                
                const range = document.createRange();
                
                // 检查编辑器内容是否合法
                if (!editor.isConnected) return;
                
                // 如果editor有内容，选择editor的最后位置
                if (editor.childNodes.length > 0) {
                    const lastChild = editor.lastChild;
                    if (!lastChild || !lastChild.isConnected) return;
                    
                    try {
                        range.selectNodeContents(lastChild);
                        range.collapse(false); // 折叠到末尾
                    } catch (err) {
                        console.warn('无法选择节点内容:', err);
                        return;
                    }
                } else {
                    // 如果editor没有内容，直接选择editor本身
                    try {
                        range.selectNodeContents(editor);
                        range.collapse(true);
                    } catch (err) {
                        console.warn('无法选择编辑器内容:', err);
                        return;
                    }
                }
                
                // 应用选择
                try {
                    selection.removeAllRanges();
                    selection.addRange(range);
                    
                    // 确保光标可见
                    editor.scrollTop = editor.scrollHeight;
                } catch (err) {
                    console.warn('无法应用选择范围:', err);
                }
            }
        } catch (error) {
            console.warn('设置选择范围时出错:', error);
        }
    }
    
    // 保存编辑器内容
    if (typeof savePageContent === 'function') {
        savePageContent();
    }
}

// 点击其他地方关闭AI输入框
function closeAIInputIfOutside(e) {
    const editor = document.getElementById('editor');
    if (!editor) return;
    
    const aiInput = editor.querySelector('.ai-input-container.active');
    if (!aiInput) return;
    
    const modelSelect = aiInput?.querySelector('.model-select');
    
    // 如果点击的是模型选择器或其选项，不关闭输入框
    if (e.target === modelSelect || e.target.closest('option')) {
        e.stopPropagation();
        return;
    }
    
    if (aiInput && !aiInput.contains(e.target)) {
        if (aiInput.parentNode) {
            aiInput.parentNode.removeChild(aiInput);
        }

        // 安全地将光标移动到编辑器内
        try {
            // 确保编辑器可见且在文档中
            if (editor && document.body.contains(editor)) {
                // 创建一个新的范围
                const selection = window.getSelection();
                if (!selection) return;
                
                const range = document.createRange();
                
                // 检查编辑器内容是否合法
                if (!editor.isConnected) return;
                
                // 如果editor有内容，选择editor的最后位置
                if (editor.childNodes.length > 0) {
                    const lastChild = editor.lastChild;
                    if (!lastChild || !lastChild.isConnected) return;
                    
                    try {
                        range.selectNodeContents(lastChild);
                        range.collapse(false); // 折叠到末尾
                    } catch (err) {
                        console.warn('无法选择节点内容:', err);
                        return;
                    }
                } else {
                    // 如果editor没有内容，直接选择editor本身
                    try {
                        range.selectNodeContents(editor);
                        range.collapse(true);
                    } catch (err) {
                        console.warn('无法选择编辑器内容:', err);
                        return;
                    }
                }
                
                // 应用选择
                try {
                    selection.removeAllRanges();
                    selection.addRange(range);
                    
                    // 确保光标可见
                    editor.scrollTop = editor.scrollHeight;
                } catch (err) {
                    console.warn('无法应用选择范围:', err);
                }
            }
        } catch (error) {
            console.warn('设置选择范围时出错:', error);
        }
    }
}

// 显示API密钥通知
function showAPIKeyNotification() {
    // 创建一个友好的通知
    const notification = document.createElement('div');
    notification.className = 'error-message';
    notification.innerHTML = `
        <strong>需要配置API</strong>
        <p>您需要设置API密钥才能使用AI功能。</p>
        <div class="error-help">
            <p>请点击下方按钮打开设置面板：</p>
            <button class="settings-open-btn">打开设置</button>
        </div>
    `;
    
    // 添加到body
    document.body.appendChild(notification);
    
    // 设置样式
    Object.assign(notification.style, {
        position: 'fixed',
        top: '20px',
        right: '20px',
        zIndex: 9999,
        maxWidth: '300px',
        animation: 'slideIn 0.3s forwards'
    });
    
    // 创建动画
    const style = document.createElement('style');
    style.innerHTML = `
        @keyframes slideIn {
            from { transform: translateX(100%); opacity: 0; }
            to { transform: translateX(0); opacity: 1; }
        }
        .settings-open-btn {
            padding: 8px 15px;
            background-color: #007AFF;
            color: white;
            border: none;
            border-radius: 10px;
            cursor: pointer;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            margin-top: 10px;
        }
        .settings-open-btn:hover {
            background-color: #0062CC;
        }
    `;
    document.head.appendChild(style);
    
    // 添加点击事件
    const openSettingsBtn = notification.querySelector('.settings-open-btn');
    openSettingsBtn.addEventListener('click', function() {
        // 如果存在设置面板函数，则调用
        if (typeof toggleSettingsPanel === 'function') {
            toggleSettingsPanel();
        }
        document.body.removeChild(notification);
    });
    
    // 3秒后自动消失
    setTimeout(() => {
        if (document.body.contains(notification)) {
            notification.style.animation = 'slideOut 0.3s forwards';
            setTimeout(() => {
                if (document.body.contains(notification)) {
                    document.body.removeChild(notification);
                }
            }, 300);
        }
    }, 5000);
    
    style.innerHTML += `
        @keyframes slideOut {
            from { transform: translateX(0); opacity: 1; }
            to { transform: translateX(100%); opacity: 0; }
        }
    `;
}

// 格式化Markdown文本
function formatMarkdown(text) {
    if (!text) return '';
    
    // 替换加粗
    text = text.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
    
    // 替换斜体
    text = text.replace(/\*(.*?)\*/g, '<em>$1</em>');
    
    // 替换代码块
    text = text.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
    
    // 替换行内代码
    text = text.replace(/`([^`]+)`/g, '<code>$1</code>');
    
    // 替换标题
    text = text.replace(/^### (.*$)/gm, '<h3>$1</h3>');
    text = text.replace(/^## (.*$)/gm, '<h2>$1</h2>');
    text = text.replace(/^# (.*$)/gm, '<h1>$1</h1>');
    
    // 替换列表
    text = text.replace(/^\s*- (.*$)/gm, '<li>$1</li>');
    text = text.replace(/^\s*\d+\. (.*$)/gm, '<li>$1</li>');
    
    // 替换链接
    text = text.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2" target="_blank">$1</a>');
    
    // 替换换行符为<br>
    text = text.replace(/\n/g, '<br>');
    
    return text;
}

// 打开设置面板的函数
function openSettingsPanel() {
    if (typeof toggleSettingsPanel === 'function') {
        toggleSettingsPanel();
        return true;
    }
    return false;
}

// 确保函数可以全局访问
window.openSettingsPanel = openSettingsPanel;

// 导出函数
window.setupAIPrompt = setupAIPrompt;
window.getLineStart = getLineStart;
window.openAIInput = openAIInput;
window.acceptAIResponse = acceptAIResponse;
window.rejectAIResponse = rejectAIResponse;
window.closeAIInputIfOutside = closeAIInputIfOutside;

// 处理发送消息
async function handleSendMessage(message, model, aiInput, responseContainer) {
    console.log('处理发送消息:', message, '模型:', model);
    
    // 显示加载指示器
    responseContainer.innerHTML = '<div class="loading-indicator"><span></span><span></span><span></span></div>';
    
    try {
        // 设置支持的模型列表
        const validModels = ['qwen', 'deepseek', 'r1-qwen-32', 'r1-llama-70', 'qwq-32b'];
        
        // 验证模型
        if (!validModels.includes(model)) {
            console.warn(`未知模型 ${model}，使用默认模型 qwen`);
            model = 'qwen'; // 默认回退到qwen
        }
        
        // 根据模型类型构建不同的请求格式
        let requestBody;
        
        // 获取API密钥
        const apiKey = CONFIG && CONFIG.apiKey ? CONFIG.apiKey : null;
        
        if (!apiKey) {
            throw new Error('缺少API密钥，请在设置中配置');
        }
        
        // 构建请求
        if (model === 'qwq-32b') {
            // QWQ-32B模型使用独特的chat/completions端点和格式
            // 完全按照官方示例重新构建请求
            requestBody = {
                model: "qwq-32b",
                messages: [
                    {
                        role: "system",
                        content: "You are a helpful assistant."
                    },
                    {
                        role: "user",
                        content: message
                    }
                ],
                stream: true // QWQ-32B模型必须使用流式模式
            };
            
            console.log('使用QWQ-32B官方格式（流式模式）');
        } else {
            // 其他模型使用通义千问格式
            const modelName = model === 'qwen' ? 'qwen-max' : 
                              model === 'deepseek' ? 'deepseek-chat' : 
                              model === 'r1-qwen-32' ? 'qwen-plus' :
                              model === 'r1-llama-70' ? 'llama-70b' : 'qwen-max';
            
            requestBody = {
                model: modelName,
                input: {
                    messages: [
                        {
                            role: "system",
                            content: "You are a helpful assistant."
                        },
                        {
                            role: "user",
                            content: message
                        }
                    ]
                },
                parameters: {}
            };
        }
        
        // 记录请求信息
        console.log('请求体:', JSON.stringify(requestBody, null, 2));
        
        // 发送API请求
        try {
            // 所有模型都使用相同的API端点
            const proxyUrl = '/api/proxy';
            console.log('发送请求到代理URL:', proxyUrl);
            
            // 特殊处理QWQ-32B的流式响应
            if (model === 'qwq-32b') {
                console.log('处理QWQ-32B的流式响应');
                
                // 显示加载指示器
                responseContainer.innerHTML = '<div class="loading-indicator"><span></span><span></span><span></span></div>';
                
                // 创建累积文本的变量
                let accumulatedText = '';
                
                const response = await fetch(proxyUrl, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `Bearer ${apiKey}`
                    },
                    body: JSON.stringify(requestBody)
                });
                
                // 检查响应状态
                if (!response.ok) {
                    const errorText = await response.text();
                    console.error('QWQ-32B API响应错误:', response.status, errorText);
                    throw new Error(`API请求失败: ${response.statusText}`);
                }
                
                try {
                    // 创建读取器读取流数据
                    const reader = response.body.getReader();
                    const decoder = new TextDecoder();
                    let done = false;
                    
                    console.log('开始读取QWQ-32B流式响应');
                    
                    // 当前收集的部分响应
                    let buffer = '';
                    
                    // 更新UI显示加载中
                    responseContainer.innerHTML = `
                        <div class="ai-loading">
                            <div class="loading-indicator"><span></span><span></span><span></span></div>
                            <div class="partial-response"></div>
                        </div>
                    `;
                    
                    const partialResponseElement = responseContainer.querySelector('.partial-response');
                    
                    while (!done) {
                        const { value, done: doneReading } = await reader.read();
                        done = doneReading;
                        
                        if (done) {
                            console.log('完成读取QWQ-32B流式响应');
                            break;
                        }
                        
                        // 解码新的数据块
                        const chunk = decoder.decode(value, { stream: true });
                        console.log('接收数据块:', chunk.length, '字节');
                        
                        // 添加到缓冲区
                        buffer += chunk;
                        
                        // 寻找完整的JSON对象
                        let jsonObjects = [];
                        
                        // 尝试提取完整的JSON对象，处理特殊格式
                        try {
                            // 检查数据是否以data:开头(SSE格式)
                            if (buffer.includes('data:')) {
                                const dataLines = buffer.split('\n')
                                    .filter(line => line.startsWith('data:'))
                                    .map(line => line.substring(5).trim());
                                
                                // 处理每一行data
                                for (const dataLine of dataLines) {
                                    if (dataLine === '[DONE]') {
                                        console.log('收到流结束标记');
                                        continue;
                                    }
                                    
                                    try {
                                        const jsonData = JSON.parse(dataLine);
                                        jsonObjects.push(jsonData);
                                    } catch (e) {
                                        console.log('无法解析SSE数据行:', dataLine);
                                    }
                                }
                                
                                // 清除已处理的数据
                                const lastDataIndex = buffer.lastIndexOf('data:');
                                if (lastDataIndex > -1) {
                                    const lastNewlineAfterData = buffer.indexOf('\n\n', lastDataIndex);
                                    if (lastNewlineAfterData > -1) {
                                        buffer = buffer.substring(lastNewlineAfterData + 2);
                                    }
                                }
                            } else {
                                // 尝试按普通JSON解析，可能有多个JSON对象
                                // 先用尝试处理换行分隔的JSON
                                const lines = buffer.split('\n').filter(line => line.trim());
                                
                                for (const line of lines) {
                                    // 忽略空行和注释
                                    if (!line.trim() || line.trim().startsWith('//')) {
                                        continue;
                                    }
                                    
                                    try {
                                        // 清理行数据 - 删除控制字符和不可打印字符
                                        const cleanedLine = line.replace(/[\x00-\x1F\x7F-\x9F]/g, '');
                                        
                                        // 有些流会在JSON前后添加特殊字符如花括号，尝试查找JSON的实际起始和结束位置
                                        let jsonStart = cleanedLine.indexOf('{');
                                        let jsonEnd = cleanedLine.lastIndexOf('}') + 1;
                                        
                                        if (jsonStart >= 0 && jsonEnd > jsonStart) {
                                            const jsonCandidate = cleanedLine.substring(jsonStart, jsonEnd);
                                            const jsonData = JSON.parse(jsonCandidate);
                                            jsonObjects.push(jsonData);
                                        } else {
                                            // 可能不是JSON对象，而是简单的文本数据
                                            if (cleanedLine && !cleanedLine.match(/[{}\[\]]/)) {
                                                // 可能是纯文本响应
                                                jsonObjects.push({ text: cleanedLine });
                                            }
                                        }
                                    } catch (parseError) {
                                        console.log('尝试解析行失败, 长度:', line.length, '内容预览:', line.substring(0, 50));
                                        // 保留在buffer中，可能是不完整的JSON
                                    }
                                }
                                
                                // 清理已尝试解析的行
                                if (lines.length > 0) {
                                    buffer = ''; // 清空缓冲区，保留可能部分解析的最后一行
                                }
                            }
                        } catch (e) {
                            console.error('流数据处理主循环错误:', e);
                        }
                        
                        // 处理提取的JSON对象
                        for (const jsonData of jsonObjects) {
                            try {
                                console.log('处理解析的JSON对象:', JSON.stringify(jsonData).substring(0, 100) + '...');
                                
                                let content = '';
                                
                                // 提取内容 - 检查多种可能的格式
                                if (jsonData.choices && jsonData.choices[0]) {
                                    if (jsonData.choices[0].delta) {
                                        // 标准流式delta格式
                                        if (jsonData.choices[0].delta.content) {
                                            content = jsonData.choices[0].delta.content;
                                        } else if (jsonData.choices[0].delta.reasoning_content) {
                                            content = jsonData.choices[0].delta.reasoning_content;
                                        }
                                    } else if (jsonData.choices[0].message && jsonData.choices[0].message.content) {
                                        // 完整消息格式
                                        content = jsonData.choices[0].message.content;
                                    }
                                } else if (jsonData.text) {
                                    // 简单文本格式
                                    content = jsonData.text;
                                } else if (jsonData.content) {
                                    // 直接内容格式
                                    content = jsonData.content;
                                } else if (jsonData.reasoning_content) {
                                    // QWQ特殊格式
                                    content = jsonData.reasoning_content;
                                }
                                
                                if (content) {
                                    accumulatedText += content;
                                    
                                    // 更新部分响应显示
                                    if (partialResponseElement) {
                                        partialResponseElement.innerHTML = formatMarkdown(accumulatedText);
                                        // 自动滚动到底部
                                        partialResponseElement.scrollTop = partialResponseElement.scrollHeight;
                                    }
                                } else {
                                    console.log('解析的JSON对象没有可提取的文本内容');
                                }
                            } catch (jsonProcessError) {
                                console.error('处理JSON对象错误:', jsonProcessError);
                            }
                        }
                    }
                    
                    console.log('QWQ-32B响应完成');
                    
                    // 移除响应容器中的加载指示器
                    responseContainer.innerHTML = '';
                    
                    // 显示最终结果
                    acceptAIResponse(message, accumulatedText, aiInput);
                    
                } catch (streamError) {
                    console.error('流处理错误:', streamError);
                    throw new Error(`流数据处理错误: ${streamError.message}`);
                }
                
                return; // 流处理完成，退出函数
            }
            
            // 非流式请求的处理
            const response = await fetch(proxyUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${apiKey}`
                },
                body: JSON.stringify(requestBody)
            });
            
            // 详细记录响应状态
            console.log('API响应状态:', response.status, response.statusText);
            
            // 处理响应
            if (!response.ok) {
                const errorText = await response.text();
                console.error('API响应错误详情:', errorText);
                throw new Error(`API请求失败: ${response.statusText}`);
            }
            
            // 解析JSON响应
            const responseText = await response.text();
            console.log('原始响应文本:', responseText.substring(0, 200) + '...');
            
            let data;
            try {
                data = JSON.parse(responseText);
                console.log('解析后的响应数据:', JSON.stringify(data).substring(0, 500) + '...');
            } catch (jsonError) {
                console.error('JSON解析错误:', jsonError);
                throw new Error('无法解析API响应');
            }
            
            let answer = '';
            
            // 特殊处理QWQ-32B的响应格式
            if (model === 'qwq-32b') {
                if (data.choices && data.choices[0] && data.choices[0].message) {
                    // OpenAI兼容格式的标准结构
                    answer = data.choices[0].message.content;
                    console.log('从QWQ-32B标准格式获取回答');
                } else if (data.reasoning_content) {
                    // 本地模型特殊格式可能包含reasoning_content
                    answer = data.reasoning_content;
                    if (data.content) {
                        answer += "\n\n" + data.content;
                    }
                    console.log('从QWQ-32B特殊格式获取回答');
                } else {
                    console.warn('未识别的QWQ-32B响应格式，尝试通用解析');
                    answer = findTextInObjectForQWQ(data);
                }
            } 
            // 通用响应处理，检查多种可能的返回格式
            else if (data.output && data.output.text) {
                answer = data.output.text;
                console.log('从output.text获取回答');
            } else if (data.output && data.output.choices && data.output.choices[0]) {
                answer = data.output.choices[0].message.content;
                console.log('从output.choices[0].message.content获取回答');
            } else if (data.choices && data.choices[0] && data.choices[0].message) {
                answer = data.choices[0].message.content;
                console.log('从choices[0].message.content获取回答');
            } else if (data.result) {
                answer = data.result;
                console.log('从result获取回答');
            } else {
                console.warn('未能识别的响应格式:', JSON.stringify(data).substring(0, 300) + '...');
                // 尝试查找任何可能的文本内容
                if (typeof data === 'object') {
                    const possibleAnswer = findTextInObject(data);
                    if (possibleAnswer) {
                        answer = possibleAnswer;
                        console.log('从对象中找到可能的答案');
                    } else {
                        answer = '(无法解析API的响应格式，请尝试其他模型)';
                    }
                } else {
                    answer = '(无法解析API的响应格式，请尝试其他模型)';
                }
            }
            
            console.log('提取的回答:', answer.substring(0, 100) + '...');
            
            // 清空加载指示器
            responseContainer.innerHTML = '';
            
            // 在UI中显示完整回答
            acceptAIResponse(message, answer, aiInput);
            
        } catch (fetchError) {
            console.error('请求API时出错:', fetchError);
            throw new Error(`网络请求失败: ${fetchError.message}。请检查API URL是否正确或网络连接是否正常。`);
        }
    } catch (err) {
        console.error('AI响应错误:', err);
        
        // 清空加载指示器并显示错误
        responseContainer.innerHTML = `
            <div class="error-message">
                <strong>错误:</strong> ${err.message}
                <div class="error-help">
                    <p>可能的原因:</p>
                    <ul>
                        <li>API密钥未配置或无效</li>
                        <li>服务器连接问题</li>
                        <li>模型暂时不可用</li>
                        <li>请求格式不符合API要求</li>
                    </ul>
                    <p>
                        <a href="#" onclick="openSettingsPanel(); return false;">检查设置</a>
                    </p>
                </div>
            </div>
        `;
        
        // 显示错误提示
        showToast(err.message, 'error');
    }
}

// 专门为QWQ-32B模型提供的文本查找函数
function findTextInObjectForQWQ(obj) {
    // 先尝试特殊字段
    if (obj.content) return obj.content;
    if (obj.answer) return obj.answer;
    if (obj.response) return obj.response;
    if (obj.message && obj.message.content) return obj.message.content;
    
    // 然后使用通用查找
    return findTextInObject(obj) || JSON.stringify(obj);
}

// 递归查找对象中的文本内容
function findTextInObject(obj, maxDepth = 3, currentDepth = 0) {
    if (currentDepth > maxDepth) return null;
    
    if (typeof obj === 'string' && obj.length > 10) {
        return obj;
    }
    
    if (typeof obj !== 'object' || obj === null) {
        return null;
    }
    
    for (const key of Object.keys(obj)) {
        // 优先检查内容相关的键
        const priorityKeys = ['text', 'content', 'message', 'answer', 'result', 'response'];
        if (priorityKeys.includes(key.toLowerCase()) && typeof obj[key] === 'string' && obj[key].length > 10) {
            return obj[key];
        }
        
        const value = obj[key];
        if (typeof value === 'object' && value !== null) {
            const result = findTextInObject(value, maxDepth, currentDepth + 1);
            if (result) {
                return result;
            }
        }
    }
    
    // 如果没有找到优先键，则检查任何长字符串
    for (const key of Object.keys(obj)) {
        if (typeof obj[key] === 'string' && obj[key].length > 30) {
            return obj[key];
        }
    }
    
    return null;
}

// 显示Toast通知
function showToast(message, type = 'success') {
    // 移除现有的toast
    const existingToast = document.querySelector('.toast');
    if (existingToast) {
        existingToast.remove();
    }
    
    // 创建新的toast
    const toast = document.createElement('div');
    toast.className = `toast ${type}`;
    toast.innerHTML = message;
    document.body.appendChild(toast);
    
    // 显示动画
    setTimeout(() => {
        toast.classList.add('show');
    }, 10);
    
    // 自动隐藏
    setTimeout(() => {
        toast.classList.remove('show');
        setTimeout(() => {
            if (toast.parentNode) {
                toast.parentNode.removeChild(toast);
            }
        }, 300);
    }, 3000);
} 